import os
import sys
import glob
import tempfile
import shutil
import re
from datetime import datetime
from flask import Flask, request, render_template, send_file, redirect, url_for, flash, jsonify
from werkzeug.utils import secure_filename

app = Flask(__name__)
app.secret_key = 'sql_merge_tool_secret_key'
app.config['UPLOAD_FOLDER'] = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'uploads')
app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024  # 限制上传大小为16MB

# 确保上传目录存在
os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)

def split_sql_statements(sql_content):
    """
    拆分SQL文件中的多个SQL语句
    
    参数:
    sql_content -- SQL文件的内容
    
    返回:
    list -- SQL语句列表
    """
    # 使用正则表达式匹配SQL语句，考虑到分号可能在字符串内或注释中
    # 这是一个简单实现，复杂情况可能需要更复杂的解析器
    statements = []
    current_statement = []
    
    # 按行拆分
    lines = sql_content.split('\n')
    
    for line in lines:
        # 忽略空行和仅包含注释的行
        stripped_line = line.strip()
        if not stripped_line or stripped_line.startswith('--'):
            if current_statement:  # 保留SQL语句中的注释和空行
                current_statement.append(line)
            continue
        
        # 检查行是否以分号结尾
        if stripped_line.endswith(';'):
            current_statement.append(line)
            statements.append('\n'.join(current_statement))
            current_statement = []
        else:
            current_statement.append(line)
    
    # 处理最后一个没有分号结尾的语句
    if current_statement:
        statements.append('\n'.join(current_statement))
    
    return statements

def merge_sql_files(directory_path, output_file='combined.sql', selected_files=None):
    """
    合并指定目录下所有SQL文件到一个文件
    
    参数:
    directory_path -- SQL文件所在目录
    output_file -- 输出文件名，默认为'combined.sql'
    selected_files -- 指定要合并的文件列表，默认为None表示合并所有SQL文件
    """
    # 确保目录路径存在
    if not os.path.exists(directory_path):
        print(f"错误: 目录 '{directory_path}' 不存在")
        return False
    
    # 获取目录中所有SQL文件
    if selected_files:
        sql_files = [os.path.join(directory_path, f) for f in selected_files 
                    if os.path.exists(os.path.join(directory_path, f))]
    else:
        sql_files = glob.glob(os.path.join(directory_path, "*.sql"))
    
    if not sql_files:
        print(f"错误: 没有找到要合并的SQL文件")
        return False
    
    # 创建输出文件
    output_path = os.path.join(directory_path, output_file)
    with open(output_path, 'w', encoding='utf-8') as outfile:
        # 遍历所有SQL文件
        for sql_file in sql_files:
            filename = os.path.basename(sql_file)
            print(f"处理文件: {filename}")
            
            # 写入文件名注释
            outfile.write(f"\n-- 来自文件: {filename}\n")
            outfile.write("-- ========================================\n")
            
            # 读取并写入SQL内容
            try:
                with open(sql_file, 'r', encoding='utf-8') as infile:
                    sql_content = infile.read()
                    # 尝试拆分SQL语句
                    statements = split_sql_statements(sql_content)
                    if len(statements) > 1:
                        print(f"在文件 {filename} 中发现 {len(statements)} 个SQL语句")
                        for i, stmt in enumerate(statements, 1):
                            if stmt.strip():  # 忽略空语句
                                outfile.write(f"\n-- 语句 {i} --\n")
                                outfile.write(stmt)
                                if not stmt.strip().endswith(';'):
                                    outfile.write(';')
                                outfile.write("\n")
                    else:
                        outfile.write(sql_content)
            except UnicodeDecodeError:
                print(f"警告: 文件 {filename} 编码不是UTF-8，尝试其他编码...")
                with open(sql_file, 'r', encoding='gbk', errors='ignore') as infile:
                    sql_content = infile.read()
                    # 尝试拆分SQL语句
                    statements = split_sql_statements(sql_content)
                    if len(statements) > 1:
                        print(f"在文件 {filename} 中发现 {len(statements)} 个SQL语句")
                        for i, stmt in enumerate(statements, 1):
                            if stmt.strip():  # 忽略空语句
                                outfile.write(f"\n-- 语句 {i} --\n")
                                outfile.write(stmt)
                                if not stmt.strip().endswith(';'):
                                    outfile.write(';')
                                outfile.write("\n")
                    else:
                        outfile.write(sql_content)
            
            outfile.write("\n\n")
    
    print(f"合并完成! 已创建文件: {output_path}")
    print(f"共合并了 {len(sql_files)} 个SQL文件")
    return output_path

def process_single_sql_file(sql_file_path, output_file='processed.sql'):
    """
    处理单个SQL文件，拆分并重组SQL语句
    
    参数:
    sql_file_path -- SQL文件路径
    output_file -- 输出文件名，默认为'processed.sql'
    """
    if not os.path.exists(sql_file_path):
        print(f"错误: 文件 '{sql_file_path}' 不存在")
        return False
    
    # 获取目录和文件名
    directory = os.path.dirname(sql_file_path)
    if not directory:
        directory = '.'
    
    # 读取SQL文件内容
    try:
        with open(sql_file_path, 'r', encoding='utf-8') as infile:
            sql_content = infile.read()
    except UnicodeDecodeError:
        print(f"警告: 文件编码不是UTF-8，尝试其他编码...")
        with open(sql_file_path, 'r', encoding='gbk', errors='ignore') as infile:
            sql_content = infile.read()
    
    # 拆分SQL语句
    statements = split_sql_statements(sql_content)
    
    if not statements:
        print("错误: 没有找到有效的SQL语句")
        return False
    
    # 创建输出文件
    output_path = os.path.join(directory, output_file)
    with open(output_path, 'w', encoding='utf-8') as outfile:
        for i, stmt in enumerate(statements, 1):
            if stmt.strip():  # 忽略空语句
                outfile.write(f"\n-- 语句 {i} --\n")
                outfile.write(stmt)
                if not stmt.strip().endswith(';'):
                    outfile.write(';')
                outfile.write("\n\n")
    
    print(f"处理完成! 已创建文件: {output_path}")
    print(f"共处理了 {len(statements)} 个SQL语句")
    return output_path

def allowed_file(filename):
    """检查文件是否为允许的SQL文件"""
    return '.' in filename and filename.rsplit('.', 1)[1].lower() == 'sql'

@app.route('/')
def index():
    """网站首页"""
    return render_template('index.html')

@app.route('/upload', methods=['POST'])
def upload_files():
    """处理文件上传请求"""
    # 检查是否有文件
    if 'files[]' not in request.files:
        flash('没有选择文件')
        return redirect(request.url)
    
    files = request.files.getlist('files[]')
    
    # 检查是否选择了文件
    if not files or files[0].filename == '':
        flash('没有选择文件')
        return redirect(request.url)
    
    # 创建会话目录
    session_dir = os.path.join(app.config['UPLOAD_FOLDER'], datetime.now().strftime('%Y%m%d%H%M%S'))
    os.makedirs(session_dir, exist_ok=True)
    
    # 保存所有上传的文件
    saved_files = []
    for file in files:
        if file and allowed_file(file.filename):
            filename = secure_filename(file.filename)
            file_path = os.path.join(session_dir, filename)
            file.save(file_path)
            saved_files.append(filename)
    
    if not saved_files:
        flash('没有有效的SQL文件')
        return redirect(url_for('index'))
    
    # 返回文件选择页面
    return render_template('select_files.html', 
                          files=saved_files, 
                          session_dir=os.path.basename(session_dir))

@app.route('/merge', methods=['POST'])
def merge_files():
    """处理文件合并请求"""
    session_dir = request.form.get('session_dir')
    selected_files = request.form.getlist('selected_files')
    output_filename = request.form.get('output_filename', 'combined.sql')
    process_mode = request.form.get('process_mode', 'merge')  # 新增处理模式
    
    if not output_filename.endswith('.sql'):
        output_filename += '.sql'
    
    # 验证会话目录
    full_session_dir = os.path.join(app.config['UPLOAD_FOLDER'], session_dir)
    if not os.path.exists(full_session_dir):
        flash('无效的会话')
        return redirect(url_for('index'))
    
    # 根据处理模式执行不同操作
    try:
        if process_mode == 'merge':
            # 合并多个文件
            if not selected_files:
                selected_files = None
            output_path = merge_sql_files(full_session_dir, output_filename, selected_files)
        elif process_mode == 'split':
            # 处理单个文件
            if not selected_files or len(selected_files) != 1:
                flash('请选择一个要处理的SQL文件')
                return redirect(url_for('index'))
            
            file_path = os.path.join(full_session_dir, selected_files[0])
            output_path = process_single_sql_file(file_path, output_filename)
        else:
            flash('无效的处理模式')
            return redirect(url_for('index'))
        
        return send_file(output_path, 
                         as_attachment=True, 
                         download_name=output_filename,
                         mimetype='application/sql')
    except Exception as e:
        flash(f'处理失败: {str(e)}')
        return redirect(url_for('index'))

@app.route('/api/upload', methods=['POST'])
def api_upload():
    """API接口：上传文件"""
    if 'files[]' not in request.files:
        return jsonify({'error': '没有选择文件'}), 400
    
    files = request.files.getlist('files[]')
    
    if not files or files[0].filename == '':
        return jsonify({'error': '没有选择文件'}), 400
    
    # 创建会话目录
    session_dir = os.path.join(app.config['UPLOAD_FOLDER'], datetime.now().strftime('%Y%m%d%H%M%S'))
    os.makedirs(session_dir, exist_ok=True)
    
    # 保存所有上传的文件
    saved_files = []
    for file in files:
        if file and allowed_file(file.filename):
            filename = secure_filename(file.filename)
            file_path = os.path.join(session_dir, filename)
            file.save(file_path)
            saved_files.append(filename)
    
    if not saved_files:
        return jsonify({'error': '没有有效的SQL文件'}), 400
    
    return jsonify({
        'success': True,
        'session_id': os.path.basename(session_dir),
        'files': saved_files
    })

@app.route('/api/merge', methods=['POST'])
def api_merge():
    """API接口：合并文件"""
    data = request.json
    
    if not data:
        return jsonify({'error': '无效的请求数据'}), 400
    
    session_dir = data.get('session_id')
    selected_files = data.get('files')
    output_filename = data.get('output_filename', 'combined.sql')
    process_mode = data.get('process_mode', 'merge')  # 新增处理模式
    
    if not output_filename.endswith('.sql'):
        output_filename += '.sql'
    
    # 验证会话目录
    full_session_dir = os.path.join(app.config['UPLOAD_FOLDER'], session_dir)
    if not os.path.exists(full_session_dir):
        return jsonify({'error': '无效的会话ID'}), 404
    
    # 根据处理模式执行不同操作
    try:
        if process_mode == 'merge':
            # 合并多个文件
            output_path = merge_sql_files(full_session_dir, output_filename, selected_files)
        elif process_mode == 'split':
            # 处理单个文件
            if not selected_files or len(selected_files) != 1:
                return jsonify({'error': '请选择一个要处理的SQL文件'}), 400
            
            file_path = os.path.join(full_session_dir, selected_files[0])
            output_path = process_single_sql_file(file_path, output_filename)
        else:
            return jsonify({'error': '无效的处理模式'}), 400
        
        # 对于API，我们返回下载链接
        download_url = url_for('download_file', session_id=session_dir, filename=output_filename, _external=True)
        return jsonify({
            'success': True,
            'download_url': download_url
        })
    except Exception as e:
        return jsonify({'error': f'处理失败: {str(e)}'}), 500

@app.route('/download/<session_id>/<filename>')
def download_file(session_id, filename):
    """下载合并后的文件"""
    file_path = os.path.join(app.config['UPLOAD_FOLDER'], session_id, filename)
    if not os.path.exists(file_path):
        flash('文件不存在')
        return redirect(url_for('index'))
    
    return send_file(file_path, 
                     as_attachment=True, 
                     download_name=filename,
                     mimetype='application/sql')

@app.route('/cleanup', methods=['POST'])
def cleanup():
    """清理上传的文件(定时任务)"""
    # 此函数可以通过定时任务调用，清理过期的上传文件
    # 实际部署时可使用Celery等任务队列
    try:
        for dirname in os.listdir(app.config['UPLOAD_FOLDER']):
            dir_path = os.path.join(app.config['UPLOAD_FOLDER'], dirname)
            # 检查目录是否超过24小时
            if os.path.isdir(dir_path):
                dir_time = datetime.fromtimestamp(os.path.getctime(dir_path))
                if (datetime.now() - dir_time).days >= 1:
                    shutil.rmtree(dir_path)
        return jsonify({'success': True})
    except Exception as e:
        return jsonify({'error': str(e)}), 500

# 创建HTML模板
@app.route('/create_templates')
def create_templates():
    """创建必要的模板文件"""
    templates_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'templates')
    os.makedirs(templates_dir, exist_ok=True)
    
    # 创建index.html
    index_html = '''
    <!DOCTYPE html>
    <html>
    <head>
        <title>SQL文件处理工具</title>
        <meta charset="utf-8">
        <meta name="viewport" content="width=device-width, initial-scale=1">
        <link href="https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/5.2.3/css/bootstrap.min.css" rel="stylesheet">
        <style>
            body { padding-top: 20px; }
            .container { max-width: 800px; }
            .flash-message { margin: 20px 0; }
            pre { background-color: #f8f9fa; padding: 10px; border-radius: 5px; }
            code { color: #d63384; }
            .api-section { margin-bottom: 20px; }
        </style>
    </head>
    <body>
        <div class="container">
            <h1 class="text-center mb-4">SQL文件处理工具</h1>
            
            {% with messages = get_flashed_messages() %}
              {% if messages %}
                {% for message in messages %}
                <div class="alert alert-warning flash-message">
                  {{ message }}
                </div>
                {% endfor %}
              {% endif %}
            {% endwith %}
            
            <div class="card">
                <div class="card-header">
                    上传SQL文件
                </div>
                <div class="card-body">
                    <form action="{{ url_for('upload_files') }}" method="post" enctype="multipart/form-data">
                        <div class="mb-3">
                            <label for="formFile" class="form-label">选择SQL文件</label>
                            <input class="form-control" type="file" id="formFile" name="files[]" multiple accept=".sql">
                            <div class="form-text">可以选择多个文件（按住Ctrl键多选）</div>
                        </div>
                        <button type="submit" class="btn btn-primary">上传文件</button>
                    </form>
                </div>
            </div>
            
            <div class="card mt-4">
                <div class="card-header">
                    功能说明
                </div>
                <div class="card-body">
                    <p>本工具提供两种处理模式：</p>
                    <ul>
                        <li><strong>合并多个SQL文件</strong>：将多个SQL文件合并为一个文件</li>
                        <li><strong>处理单个SQL文件</strong>：解析单个SQL文件中的多条SQL语句，并标记整理</li>
                    </ul>
                </div>
            </div>
            
            <div class="card mt-4">
                <div class="card-header">
                    API接口详细说明
                </div>
                <div class="card-body">
                    <div class="api-section">
                        <h5>1. 文件上传 API</h5>
                        <p><strong>请求URL：</strong> <code>POST /api/upload</code></p>
                        <p><strong>功能说明：</strong> 上传一个或多个SQL文件，创建会话</p>
                        <p><strong>请求参数：</strong></p>
                        <ul>
                            <li><code>files[]</code>：文件数组，必须是SQL文件</li>
                        </ul>
                        <p><strong>请求示例：</strong></p>
                        <pre><code>// 使用FormData发送
const formData = new FormData();
formData.append('files[]', file1);
formData.append('files[]', file2);

fetch('/api/upload', {
    method: 'POST',
    body: formData
})
.then(response => response.json())
.then(data => console.log(data));</code></pre>
                        <p><strong>成功响应：</strong></p>
                        <pre><code>{
    "success": true,
    "session_id": "20230401123456",
    "files": ["file1.sql", "file2.sql"]
}</code></pre>
                        <p><strong>错误响应：</strong></p>
                        <pre><code>{
    "error": "没有选择文件" 
}
// 状态码: 400</code></pre>
                    </div>
                    
                    <div class="api-section">
                        <h5>2. 文件处理 API</h5>
                        <p><strong>请求URL：</strong> <code>POST /api/merge</code></p>
                        <p><strong>功能说明：</strong> 处理已上传的SQL文件（合并多个文件或解析单个文件）</p>
                        <p><strong>请求格式：</strong> JSON</p>
                        <p><strong>请求参数：</strong></p>
                        <ul>
                            <li><code>session_id</code>：会话ID，通过上传API获取（必填）</li>
                            <li><code>files</code>：要处理的文件列表，不提供则处理所有文件（可选）</li>
                            <li><code>output_filename</code>：输出文件名，默认为combined.sql（可选）</li>
                            <li><code>process_mode</code>：处理模式，可选值：
                                <ul>
                                    <li><code>merge</code>：合并多个SQL文件（默认）</li>
                                    <li><code>split</code>：解析单个SQL文件中的多条语句</li>
                                </ul>
                            </li>
                        </ul>
                        <p><strong>请求示例：</strong></p>
                        <pre><code>// 合并多个文件
fetch('/api/merge', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        "session_id": "20230401123456",
        "files": ["file1.sql", "file2.sql"],
        "output_filename": "combined.sql",
        "process_mode": "merge"
    })
})
.then(response => response.json())
.then(data => console.log(data));

// 处理单个文件中的多条SQL语句
fetch('/api/merge', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        "session_id": "20230401123456",
        "files": ["file1.sql"],
        "output_filename": "processed.sql",
        "process_mode": "split"
    })
})
.then(response => response.json())
.then(data => console.log(data));</code></pre>
                        <p><strong>成功响应：</strong></p>
                        <pre><code>{
    "success": true,
    "download_url": "http://yourserver.com/download/20230401123456/combined.sql"
}</code></pre>
                        <p><strong>错误响应：</strong></p>
                        <pre><code>// 会话ID无效
{
    "error": "无效的会话ID"
}
// 状态码: 404

// 处理模式错误
{
    "error": "无效的处理模式"
}
// 状态码: 400

// 处理单个文件时未选择文件或选择了多个文件
{
    "error": "请选择一个要处理的SQL文件"
}
// 状态码: 400</code></pre>
                    </div>

                    <div class="api-section">
                        <h5>3. 文件下载 API</h5>
                        <p><strong>请求URL：</strong> <code>GET /download/{session_id}/{filename}</code></p>
                        <p><strong>功能说明：</strong> 下载处理后的SQL文件</p>
                        <p><strong>URL参数：</strong></p>
                        <ul>
                            <li><code>session_id</code>：会话ID</li>
                            <li><code>filename</code>：文件名</li>
                        </ul>
                        <p><strong>示例：</strong></p>
                        <pre><code>// 直接在浏览器中打开下载链接
window.location.href = "http://yourserver.com/download/20230401123456/combined.sql";

// 或使用fetch下载
fetch("http://yourserver.com/download/20230401123456/combined.sql")
.then(response => response.blob())
.then(blob => {
    const url = window.URL.createObjectURL(blob);
    const a = document.createElement('a');
    a.style.display = 'none';
    a.href = url;
    a.download = 'combined.sql';
    document.body.appendChild(a);
    a.click();
    window.URL.revokeObjectURL(url);
});</code></pre>
                    </div>
                </div>
            </div>
        </div>
        
        <script src="https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/5.2.3/js/bootstrap.bundle.min.js"></script>
    </body>
    </html>
    '''
    
    # 创建select_files.html
    select_files_html = '''
    <!DOCTYPE html>
    <html>
    <head>
        <title>选择要处理的文件</title>
        <meta charset="utf-8">
        <meta name="viewport" content="width=device-width, initial-scale=1">
        <link href="https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/5.2.3/css/bootstrap.min.css" rel="stylesheet">
        <style>
            body { padding-top: 20px; }
            .container { max-width: 800px; }
        </style>
    </head>
    <body>
        <div class="container">
            <h1 class="text-center mb-4">选择要处理的文件</h1>
            
            {% with messages = get_flashed_messages() %}
              {% if messages %}
                {% for message in messages %}
                <div class="alert alert-warning">
                  {{ message }}
                </div>
                {% endfor %}
              {% endif %}
            {% endwith %}
            
            <div class="card">
                <div class="card-header">
                    已上传的SQL文件
                </div>
                <div class="card-body">
                    <form action="{{ url_for('merge_files') }}" method="post">
                        <input type="hidden" name="session_dir" value="{{ session_dir }}">
                        
                        <div class="mb-3">
                            <label class="form-label">处理模式</label>
                            <div class="form-check">
                                <input class="form-check-input" type="radio" name="process_mode" id="mergeModeRadio" value="merge" checked>
                                <label class="form-check-label" for="mergeModeRadio">
                                    合并多个SQL文件
                                </label>
                            </div>
                            <div class="form-check">
                                <input class="form-check-input" type="radio" name="process_mode" id="splitModeRadio" value="split">
                                <label class="form-check-label" for="splitModeRadio">
                                    处理单个SQL文件中的多条语句
                                </label>
                            </div>
                            <div class="form-text" id="modeHelp">选择"处理单个SQL文件"时，请只选择一个文件</div>
                        </div>
                        
                        <div class="mb-3">
                            <label class="form-label">选择要处理的文件</label>
                            <div class="form-text mb-2" id="filesHelp">在"合并模式"下，不选择任何文件将合并所有文件</div>
                            
                            {% for file in files %}
                            <div class="form-check">
                                <input class="form-check-input file-checkbox" type="checkbox" name="selected_files" value="{{ file }}" id="file{{ loop.index }}" checked>
                                <label class="form-check-label" for="file{{ loop.index }}">
                                    {{ file }}
                                </label>
                            </div>
                            {% endfor %}
                        </div>
                        
                        <div class="mb-3">
                            <label for="outputFilename" class="form-label">输出文件名</label>
                            <input type="text" class="form-control" id="outputFilename" name="output_filename" value="combined.sql">
                        </div>
                        
                        <div class="d-flex justify-content-between">
                            <a href="{{ url_for('index') }}" class="btn btn-secondary">返回</a>
                            <button type="submit" class="btn btn-primary">处理并下载</button>
                        </div>
                    </form>
                </div>
            </div>
        </div>
        
        <script src="https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/5.2.3/js/bootstrap.bundle.min.js"></script>
        <script>
            // 当选择"处理单个SQL文件"模式时，限制只能选择一个文件
            document.getElementById('splitModeRadio').addEventListener('change', function() {
                if (this.checked) {
                    const checkboxes = document.querySelectorAll('.file-checkbox');
                    let checkedCount = 0;
                    
                    checkboxes.forEach(function(checkbox) {
                        if (checkbox.checked) checkedCount++;
                    });
                    
                    if (checkedCount !== 1) {
                        // 默认只选择第一个文件
                        checkboxes.forEach(function(checkbox, index) {
                            checkbox.checked = (index === 0);
                        });
                    }
                    
                    // 禁用其他复选框
                    checkboxes.forEach(function(checkbox) {
                        if (!checkbox.checked) {
                            checkbox.disabled = true;
                        }
                    });
                    
                    document.getElementById('filesHelp').textContent = '在"处理单个文件"模式下，请只选择一个文件';
                }
            });
            
            document.getElementById('mergeModeRadio').addEventListener('change', function() {
                if (this.checked) {
                    // 启用所有复选框
                    document.querySelectorAll('.file-checkbox').forEach(function(checkbox) {
                        checkbox.disabled = false;
                    });
                    
                    document.getElementById('filesHelp').textContent = '在"合并模式"下，不选择任何文件将合并所有文件';
                }
            });
            
            // 当文件选择改变时检查处理模式
            document.querySelectorAll('.file-checkbox').forEach(function(checkbox) {
                checkbox.addEventListener('change', function() {
                    if (document.getElementById('splitModeRadio').checked) {
                        // 在"处理单个SQL文件"模式下，确保只有一个文件被选中
                        const checkboxes = document.querySelectorAll('.file-checkbox');
                        
                        checkboxes.forEach(function(cb) {
                            if (cb !== checkbox) {
                                cb.checked = false;
                            }
                        });
                    }
                });
            });
        </script>
    </body>
    </html>
    '''
    
    # 写入模板文件
    with open(os.path.join(templates_dir, 'index.html'), 'w', encoding='utf-8') as f:
        f.write(index_html)
    
    with open(os.path.join(templates_dir, 'select_files.html'), 'w', encoding='utf-8') as f:
        f.write(select_files_html)
    
    return "模板创建成功"

def interactive_mode():
    """
    原命令行交互模式代码，保留但不再是主要使用方式
    """
    print("=== SQL文件处理工具 ===")
    
    print("请选择操作模式:")
    print("1. 合并多个SQL文件")
    print("2. 处理单个SQL文件中的多条SQL语句")
    
    mode = input("请选择 (1/2): ").strip()
    
    if mode == '1':
        # 获取目录路径
        while True:
            directory = input("请输入SQL文件所在目录: ").strip()
            if os.path.exists(directory):
                break
            print(f"错误: 目录 '{directory}' 不存在，请重新输入")
        
        # 获取并显示目录中的SQL文件
        all_sql_files = glob.glob(os.path.join(directory, "*.sql"))
        if not all_sql_files:
            print(f"警告: 在 '{directory}' 中没有找到SQL文件")
            proceed = input("是否继续? (y/n): ").lower()
            if proceed != 'y':
                return
        else:
            print(f"\n在目录 '{directory}' 中找到 {len(all_sql_files)} 个SQL文件:")
            for i, file in enumerate(all_sql_files, 1):
                print(f"  {i}. {os.path.basename(file)}")
        
        # 询问是否选择特定文件
        select_specific = input("\n是否选择特定文件合并? (y/n，默认n合并所有): ").lower()
        selected_files = None
        
        if select_specific == 'y':
            print("输入要合并的文件编号，多个编号用逗号分隔，例如: 1,3,5")
            print("输入 'all' 选择所有文件")
            
            while True:
                selection = input("请选择: ").strip()
                
                if selection.lower() == 'all':
                    break
                    
                try:
                    # 解析用户输入的编号
                    indices = [int(idx.strip()) for idx in selection.split(',') if idx.strip()]
                    # 检查编号是否有效
                    if all(1 <= idx <= len(all_sql_files) for idx in indices):
                        selected_files = [os.path.basename(all_sql_files[idx-1]) for idx in indices]
                        break
                    else:
                        print("错误: 有无效的文件编号，请重新输入")
                except ValueError:
                    print("错误: 请输入有效的数字编号")
        
        # 获取输出文件名
        default_output = 'combined.sql'
        output = input(f"\n请输入输出文件名 (默认: {default_output}): ").strip()
        if not output:
            output = default_output
        
        # 确认操作
        files_count = len(selected_files) if selected_files else len(all_sql_files)
        print(f"\n即将合并 {files_count} 个SQL文件到 '{output}'")
        confirm = input("确认执行? (y/n): ").lower()
        
        if confirm == 'y':
            merge_sql_files(directory, output, selected_files)
        else:
            print("操作已取消")
    
    elif mode == '2':
        # 处理单个SQL文件
        while True:
            file_path = input("请输入SQL文件路径: ").strip()
            if os.path.exists(file_path) and os.path.isfile(file_path):
                break
            print(f"错误: 文件 '{file_path}' 不存在，请重新输入")
        
        # 获取输出文件名
        default_output = 'processed.sql'
        output = input(f"\n请输入输出文件名 (默认: {default_output}): ").strip()
        if not output:
            output = default_output
        
        # 确认操作
        print(f"\n即将处理文件 '{os.path.basename(file_path)}' 并输出到 '{output}'")
        confirm = input("确认执行? (y/n): ").lower()
        
        if confirm == 'y':
            process_single_sql_file(file_path, output)
        else:
            print("操作已取消")
    
    else:
        print("无效的选择")

if __name__ == "__main__":
    if len(sys.argv) > 1:
        # 命令行模式
        if sys.argv[1] == '--server':
            # 创建模板
            create_templates()
            # 启动Flask服务器
            port = int(sys.argv[2]) if len(sys.argv) > 2 else 5000
            app.run(host='0.0.0.0', port=port, debug=False)
        elif sys.argv[1] == '--process' and len(sys.argv) > 2:
            # 处理单个SQL文件
            file_path = sys.argv[2]
            output = sys.argv[3] if len(sys.argv) > 3 else 'processed.sql'
            process_single_sql_file(file_path, output)
        else:
            directory = sys.argv[1]
            output = sys.argv[2] if len(sys.argv) > 2 else 'combined.sql'
            merge_sql_files(directory, output)
    else:
        # 默认启动Flask服务器
        create_templates()
        app.run(host='0.0.0.0', port=5000, debug=True)
#python -m pip install flask werkzeug